package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"log"
	"time"

	serial "github.com/jacobsa/go-serial/serial"
)

// 定义与JSON结构匹配的结构体
type FileInfo struct {
	FileSize int    `json:"filesize"`
	Md5      string `json:"md5"`
	Ver      int    `json:"ver"`
}

var fileInfo FileInfo
var filesize = 0
var txByte = make([]byte, 256)
var done= false
func formate_txByte() bool{
	addr := filesize
	length := 4096
	filesize += length

	if addr+length > fileInfo.FileSize {
		length = fileInfo.FileSize - addr
		fmt.Printf("调整后的 length: %d\n", length)
		if length <= 0 {
			done = true
			return false
		}
	}

	// 定义数据结构
	type Data struct {
		Addr int `json:"addr"`
		Len  int `json:"len"`
	}

	// 创建数据对象
	data := Data{
		Addr: addr,
		Len:  length,
	}

	// 序列化为JSON
	jsonData, err := json.Marshal(data)
	if err != nil {
		fmt.Printf("JSON序列化失败: %v\n", err)
		return false
	}

	// 加上前缀并输出
	result := "2###" + string(jsonData)
	//fmt.Println(result)
	copy(txByte, bytes.Repeat([]byte{0}, len(txByte))) // 清空 txByte

	copy(txByte, []byte(result))
	return true
}

func cleanJSON(data []byte) []byte {
	end := bytes.LastIndexByte(data, '}') // 找到最后一个 }
	if end == -1 {
		log.Printf("cleanJSON failed-----------\n")
		return nil // 无有效JSON
	}
	log.Printf("cleanJSON ok---------------------\n")
	return data[:end+1] // 截取到 } 的位置（包含）
}

func handleType1(jsonData []byte) {
	fmt.Println(string(jsonData))
	jsonInfo := cleanJSON(jsonData)
	fmt.Println(string(jsonInfo))

	err := json.Unmarshal(jsonInfo, &fileInfo)
	if err != nil {
		log.Printf("处理类型数据失败: %v\n", err)
		return
	}

	fmt.Println("处理类型数据成功:")
	fmt.Printf(" - 文件大小: %d\n", fileInfo.FileSize)
	fmt.Printf(" - MD5值: %s\n", fileInfo.Md5)
	fmt.Printf(" - 版本号: %d\n\n", fileInfo.Ver)
	formate_txByte()
}

func handleType3(jsonData []byte) {
	 formate_txByte()
}
func main() {

	options := serial.OpenOptions{
		PortName:        "com2",
		BaudRate:        115200,
		DataBits:        8,
		StopBits:        1,
		MinimumReadSize: 4,
	}

	port, err := serial.Open(options)
	if err != nil {
		log.Fatalf("serial.Open: %v", err)
	}

	defer port.Close()

	//*绝对的从机 只有主机过来消息 才回答一句话  开始死循环 等待主机消息过来
	rxByte := make([]byte, 4100)

	for {
		n, err := port.Read(rxByte)
		if err != nil {
			log.Fatal(err)
		}
		if n > 1 {

			//fmt.Printf("%s", rxByte[:n])
			// 获取前4个字节作为标识符
			head := string(rxByte[:4])
			body := rxByte[4:]

			// 根据不同的前缀进行不同处理
			switch head {
			case "1###":
				handleType1(body)
			case "3###":
				handleType3(body)
			default:
				log.Printf("未知的前缀: %s 无法处理\n", head)
			}
			if done {
				copy(rxByte, bytes.Repeat([]byte{0}, len(rxByte))) // 清空 rxByte
				filesize=0
				done=false
				continue
				//break//GUI关闭了
			}
			fmt.Println(string(txByte))
			port.Write(txByte)
			time.Sleep(1)
		}
	}
}
